package com.helloandroid.app.model

import android.os.Build
import androidx.lifecycle.ViewModel
import androidx.lifecycle.viewModelScope
import com.business.Analyse
import com.business.AnalyseKey
import com.helloandroid.AppUtil
import com.helloandroid.MyApplication
import com.helloandroid.ServerConfig
import com.helloandroid.tools.AppConfig
import com.helloandroid.tools.GUtils
import com.helloandroid.tools.GUtils.httpWithTimeOut
import com.helloandroid.tools.MyLog
import com.helloandroid.tools.NetWorkUtil
import dai.android.util.AndroidUtils
import kotlinx.coroutines.*
import java.lang.Exception

class WelcomeViewModel : ViewModel() {

    fun loadConfig(callback: (Boolean) -> Unit) {

        if (!NetWorkUtil.networkConnected()) {
            AppUtil.toast("请打开网络!")
            callback(false)
            return
        }

        if (AppConfig.isDebug && AppConfig.IgnoreServerConfig) {
            MyLog.info("=================忽略服务端配置========================")
            callback(false)
            return
        }

        val versionName = AndroidUtils.getAppVersionName(MyApplication.app)

        // 1. 检查本地配置是否存在. 如果不存在,则从服务器读取. 如果存在则直接使用.
        val pref = MyApplication.getPerference("app_config")
        if (ServerConfig.isConfigExist(pref)) {
            // 配置存在,直接读
            val config = ServerConfig.loadFromPreference(pref)
            AppUtil.serverConfig.copyFrom(config)
            AppConfig.isFake = config.ignoreVersion == versionName
            MyLog.info("读取的本地数据, 读取最新配置")
            AppUtil.appViewModel().loadServerConfig(0) { configStr ->
                if (!configStr.isNullOrEmpty()) {
                    val config = GUtils.parserServerConfig(configStr)
                    config.saveConfig(pref)
                }
            }
            callback(true)
        } else {
            // 不存在,直接从服务器读
            MyLog.info("本地不存在,直接从服务器读...")
            AppUtil.appViewModel().loadServerConfig(6000L) { configStr ->
                if (!configStr.isNullOrEmpty()) {
                    val config = GUtils.parserServerConfig(configStr)
                    AppConfig.isFake = config.ignoreVersion == versionName
                    AppUtil.serverConfig.copyFrom(config)
                    config.saveConfig(pref)
                    callback(true)
                } else {
                    callback(false)
                }
            }
        }
    }

    fun get_sysbs_from_service(callback: (Int) -> Unit) {
        viewModelScope.launch {
            var sysbs = -1

            // 3s读不到就直接返回0,保证登陆
            withTimeout(3000L) {
                try {
                    while (isActive) {
                        if (MyApplication.app.serverProxy != null) {
                            sysbs = MyApplication.app.serverProxy!!.querySysbs()
                            if (sysbs >= 0) {
                                break
                            }
                        }
                        delay(30L)
                    }
                    MyLog.info("**** sysbs:${sysbs}")
                    callback(sysbs)
                } catch (e: Exception) {
                    MyLog.info("读取系统步数超时!")
                    Analyse.report(AnalyseKey.Sys_RdBsTimeOut)

                    when (Build.VERSION.SDK_INT) {
                        Build.VERSION_CODES.M -> Analyse.report(AnalyseKey.Sys_Os6)

                        Build.VERSION_CODES.N,
                        Build.VERSION_CODES.N_MR1 -> Analyse.report(AnalyseKey.Sys_Os7)

                        Build.VERSION_CODES.O,
                        Build.VERSION_CODES.O_MR1 -> Analyse.report(AnalyseKey.Sys_Os8)

                        Build.VERSION_CODES.P ->  Analyse.report(AnalyseKey.Sys_Os9)
                        Build.VERSION_CODES.Q -> Analyse.report(AnalyseKey.Sys_Os10)
                        Build.VERSION_CODES.R -> Analyse.report(AnalyseKey.Sys_Os11)
                        else -> Analyse.report(AnalyseKey.Sys_OsUnknow)
                    }

                    sysbs = 0
                    callback(0)
                }
            }
        }
    }

    fun preventSplashCallback(callback:()->Unit){
        viewModelScope.launch {
            delay(10 * 1000)
            callback()
        }
    }
}